{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "24c88602",
   "metadata": {},
   "source": [
    "## SAC_Pendulum-v1\n",
    "\n",
    "SAC（Soft Actor-Critic）有两个版本，其中[SAC-v1](https://arxiv.org/abs/1801.01290)由Haarnoja等人于2018年提出，也是该算法的最初版本, [SAC-v2](https://arxiv.org/abs/1812.05905)则是于2019年提出的改进版本。其中相比于v1版本，SAC-v2主要做了两项重要改进，一是移除了Value网络，二是引入了自动调节entropy系数 $\\alpha$。\n",
    "\n",
    "由于目前主流使用的是V2版本，因此未特别说明的情况下，我们默认实现v2版本, 例如本Notebook。相比v1版本，v2版本主要去掉了Value网络，以及使用的双Q(cirtic)网络。\n",
    "\n",
    "v1版本中Value网络主要充当Actor 和 Critic 网络训练之间的桥梁，但是增加一个这样的网络会导致更多误差传播路径，并且其实可以这样构造Q的目标函数，更稳定更直接：\n",
    "\n",
    "$$\n",
    "r+\\gamma \\cdot\\left(\\min \\left(Q_1^{\\prime}, Q_2^{\\prime}\\right)-\\alpha \\log \\pi\\left(a^{\\prime} \\mid s^{\\prime}\\right)\\right)\n",
    "$$\n",
    "\n",
    "而双Q网络的作用，就跟Double DQN、TD3算法类似，多一个critic来减缓Q值的过估计。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8b892e72",
   "metadata": {},
   "source": [
    "### 定义参数\n",
    "\n",
    "为方便实验调试，把所有参数都放在一起"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "c11c4d5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "class Config:\n",
    "    def __init__(self):\n",
    "        self.algo_name = 'SAC'\n",
    "        self.env_id = 'Pendulum-v1'\n",
    "        self.mode = 'train'\n",
    "        self.seed = 0 # 随机种子\n",
    "        self.max_epsiode = 100 # 训练的回合数\n",
    "        self.max_step = 200 # 每个回合的最大步数，超过该数则游戏强制终止\n",
    "        #region 在线测试相关参数\n",
    "        self.online_eval_episode = 10 # 测试的回合数\n",
    "        self.online_eval_freq = 2000 # 在线测试的频率, 模型每更新N次就测试一次\n",
    "        #endregion\n",
    "        self.gamma = 0.99 #折扣因子\n",
    "        self.lambda_mean=1e-3 # 重参数化分布均值的损失权重\n",
    "        self.lambda_std=1e-3 # 重参数化分布标准差的损失权重\n",
    "        self.lambda_z = 0.0 # 重参数化分布抽样值的损失权重\n",
    "        self.soft_update_tau = 1e-2 # 目标网络软更新系数\n",
    "        self.lr_critic = 3e-4 # Q网络的学习率\n",
    "        self.lr_actor = 3e-4 # 策略网络的学习率\n",
    "        self.lr_alpha = 3e-4 # 温度参数的学习率\n",
    "        self.buffer_size = 100000 # 经验回放池大小\n",
    "        self.hidden_dim = 256 # 隐藏层维度\n",
    "        self.batch_size  = 256 # 批次大小\n",
    "        self.device = self._auto_get_device() # 设备\n",
    "    \n",
    "    def _auto_get_device(self):\n",
    "        _device = 'cpu'\n",
    "        if torch.cuda.is_available():\n",
    "            _device = 'cuda'\n",
    "        elif torch.backends.mps.is_available():\n",
    "            _device = 'mps'\n",
    "        return _device"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "377edc7d",
   "metadata": {},
   "source": [
    "### 定义模型\n",
    "\n",
    "去掉了Value网络之后，SAC-v2版本就是一个经典的Actor-Critic结构了。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "6218efae",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch.optim import Adam\n",
    "from torch.distributions import Normal\n",
    "import numpy as np\n",
    "\n",
    "        \n",
    "class Critic(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3):\n",
    "        super(Critic, self).__init__()\n",
    "        '''SoftQ\n",
    "        '''\n",
    "        self.linear1 = nn.Linear(state_dim + action_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        self.linear3 = nn.Linear(hidden_dim, 1)\n",
    "        \n",
    "        self.linear3.weight.data.uniform_(-init_w, init_w)\n",
    "        self.linear3.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state, action):\n",
    "        x = torch.cat([state, action], 1)\n",
    "        x = F.relu(self.linear1(x))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        x = self.linear3(x)\n",
    "        return x\n",
    "        \n",
    "        \n",
    "class Actor(nn.Module):\n",
    "    def __init__(self, state_dim, action_dim, hidden_dim, init_w=3e-3, log_std_min=-20, log_std_max=2):\n",
    "        super(Actor, self).__init__()\n",
    "        self.log_std_min = log_std_min\n",
    "        self.log_std_max = log_std_max\n",
    "        \n",
    "        self.linear1 = nn.Linear(state_dim, hidden_dim)\n",
    "        self.linear2 = nn.Linear(hidden_dim, hidden_dim)\n",
    "        \n",
    "        # 初始化权重\n",
    "        self.mean_linear = nn.Linear(hidden_dim, action_dim)\n",
    "        self.mean_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.mean_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "        self.log_std_linear = nn.Linear(hidden_dim, action_dim)\n",
    "        self.log_std_linear.weight.data.uniform_(-init_w, init_w)\n",
    "        self.log_std_linear.bias.data.uniform_(-init_w, init_w)\n",
    "        \n",
    "    def forward(self, state):\n",
    "        x = F.relu(self.linear1(state))\n",
    "        x = F.relu(self.linear2(x))\n",
    "        \n",
    "        mean    = self.mean_linear(x)\n",
    "        log_std = self.log_std_linear(x)\n",
    "        log_std = torch.clamp(log_std, self.log_std_min, self.log_std_max)\n",
    "        std = torch.exp(log_std)\n",
    "        return mean, std\n",
    "    \n",
    "    def sample(self, state):\n",
    "        mean, std = self.forward(state)\n",
    "        normal = Normal(mean, std)\n",
    "        z = normal.rsample()\n",
    "        action = torch.tanh(z)\n",
    "        # 计算log_prob\n",
    "        # 这里的log_prob是对z的log_prob\n",
    "        # 需要对z进行重参数化\n",
    "        log_prob = normal.log_prob(z) - torch.log(1 - action.pow(2) + 1e-6)\n",
    "        log_prob = log_prob.sum(1, keepdim=True)\n",
    "        return action, log_prob"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "debce530",
   "metadata": {},
   "source": [
    "### 定义经验回放\n",
    "\n",
    "经验回放主要有两个功能，一是存储样本(push)，二是随时采样样本(sample)。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "1c740ca0",
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import deque\n",
    "import random\n",
    "\n",
    "class ReplayBuffer(object):\n",
    "    def __init__(self, cfg: Config) -> None:\n",
    "        self.capacity = cfg.buffer_size\n",
    "        self.buffer = deque(maxlen=self.capacity)\n",
    "        \n",
    "    def push(self, transitions):\n",
    "        ''' 存储transition到经验回放中\n",
    "        '''\n",
    "        self.buffer.append(transitions)\n",
    "\n",
    "    def sample(self, batch_size: int, sequential: bool = False):\n",
    "        if batch_size > len(self.buffer): # 如果批量大小大于经验回放的容量，则取经验回放的容量\n",
    "            batch_size = len(self.buffer)\n",
    "        if sequential: # 顺序采样\n",
    "            rand = random.randint(0, len(self.buffer) - batch_size)\n",
    "            batch = [self.buffer[i] for i in range(rand, rand + batch_size)]\n",
    "            return zip(*batch)\n",
    "        else: # 随机采样\n",
    "            batch = random.sample(self.buffer, batch_size)\n",
    "            return zip(*batch)\n",
    "        \n",
    "    def __len__(self):\n",
    "        ''' 返回当前存储的量\n",
    "        '''\n",
    "        return len(self.buffer)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "32a65b71",
   "metadata": {},
   "source": [
    "### 定义策略\n",
    "\n",
    "SAC-v1 的value网络包含主网络和目标网络，起作用跟`DQN`中的 $Q$ 和 $Q_target$ 网络是一样的，都是为了避免估计目标Q值的剧烈波动，使得训练更加稳定。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "5a86f725",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Policy:\n",
    "    def __init__(self, cfg: Config, state_dim:int, action_dim:int) -> None:\n",
    "\n",
    "        self.batch_size  = cfg.batch_size \n",
    "        \n",
    "        self.device = torch.device(cfg.device)\n",
    "        self.gamma = cfg.gamma\n",
    "        self.lambda_mean = cfg.lambda_mean\n",
    "        self.lambda_std  = cfg.lambda_std\n",
    "        self.lambda_z    = cfg.lambda_z\n",
    "        self.soft_update_tau = cfg.soft_update_tau\n",
    "\n",
    "        # 双Q网络\n",
    "        self.critic_1 = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_2 = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_1_target = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_2_target = Critic(state_dim, action_dim, cfg.hidden_dim).to(self.device)\n",
    "        self.critic_1_target.load_state_dict(self.critic_1.state_dict())\n",
    "        self.critic_2_target.load_state_dict(self.critic_2.state_dict())\n",
    "\n",
    "        self.actor = Actor(state_dim, action_dim, cfg.hidden_dim).to(self.device)  \n",
    "\n",
    "        self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n",
    "\n",
    "        self.opt_critic_1 = Adam(self.critic_1.parameters(), lr=cfg.lr_critic)\n",
    "        self.opt_critic_2 = Adam(self.critic_2.parameters(), lr=cfg.lr_critic)\n",
    "        self.opt_actor = Adam(self.actor.parameters(), lr=cfg.lr_actor)  \n",
    "        self.opt_alpha = Adam([self.log_alpha], lr=cfg.lr_alpha) # 学习率和actor相同\n",
    "\n",
    "        self.target_entropy = -action_dim # 目标熵\n",
    "\n",
    "        self.memory = ReplayBuffer(cfg)\n",
    "\n",
    "        self.update_cnt = 0\n",
    "\n",
    "    def sample_action(self, state):\n",
    "        return self.predict_action(state)\n",
    "    \n",
    "    @torch.no_grad()\n",
    "    def predict_action(self, state):\n",
    "        state = torch.tensor(state, device=self.device, dtype=torch.float32).unsqueeze(dim=0)\n",
    "        mean, log_std = self.actor.forward(state)\n",
    "        std = log_std.exp()\n",
    "        normal = Normal(mean, std)\n",
    "        z = normal.sample()\n",
    "        action = torch.tanh(z)\n",
    "        action = action.detach().cpu().numpy()\n",
    "        return action[0]\n",
    "    \n",
    "    def get_policy_params(self):\n",
    "        '''获取策略网络的参数\n",
    "        '''\n",
    "        return self.actor.parameters()\n",
    "    \n",
    "    def set_policy_params(self, params):\n",
    "        '''设置策略网络的参数\n",
    "        '''\n",
    "        for param, new_param in zip(self.actor.parameters(), params):\n",
    "            param.data.copy_(new_param.data)\n",
    "        \n",
    "    def update(self):\n",
    "        if len(self.memory) < self.batch_size: # 当经验回放中不满足一个批量时，不更新策略\n",
    "            return \n",
    "        states, actions, rewards, next_states, dones = self.memory.sample(self.batch_size) # 从经验回放中随机采样一个批量的转移(transition)\n",
    "        # 将数据转换为tensor\n",
    "        states = torch.tensor(np.array(states), device = self.device, dtype=torch.float) # [B, state_dim]\n",
    "        actions = torch.tensor(np.array(actions), device=self.device,  dtype = torch.float)  #  [B, 1]\n",
    "        rewards = torch.tensor(rewards, device=self.device, dtype=torch.float).unsqueeze(1)   # [B, 1]\n",
    "        next_states = torch.tensor(np.array(next_states), device=self.device, dtype=torch.float) # [batchB_size, state_dim]\n",
    "        dones = torch.tensor(np.float32(dones), device=self.device).unsqueeze(1)  # [batch_size,1]\n",
    "\n",
    "        with torch.no_grad():\n",
    "            actions_next, log_probs_next = self.actor.sample(next_states) #计算t+1时刻的动作\n",
    "            q_value_1_target = self.critic_1_target(next_states, actions_next) #计算t+1时刻的q值\n",
    "            q_value_2_target = self.critic_2_target(next_states, actions_next)\n",
    "            q_value_min = torch.min(q_value_1_target, q_value_2_target) # 计算t+1时刻的q值\n",
    "            alpha = self.log_alpha.exp() # 计算温度参数\n",
    "            q_value_target = rewards + (1 - dones) * self.gamma * (q_value_min - alpha * log_probs_next) # 计算t+1时刻的q值\n",
    "        \n",
    "        q_value_1 = self.critic_1(states, actions) #计算t时刻的q值\n",
    "        q_value_2 = self.critic_2(states, actions)\n",
    "\n",
    "        loss_critic_1 = nn.MSELoss()(q_value_1, q_value_target) #计算q网络的损失函数\n",
    "        loss_critic_2 = nn.MSELoss()(q_value_2, q_value_target)\n",
    "\n",
    "        self.opt_critic_1.zero_grad()\n",
    "        loss_critic_1.backward()\n",
    "        self.opt_critic_1.step()\n",
    "\n",
    "        self.opt_critic_2.zero_grad()\n",
    "        loss_critic_2.backward()\n",
    "        self.opt_critic_2.step()\n",
    "\n",
    "        actions_new, log_probs_new = self.actor.sample(states) #计算t时刻的动作\n",
    "        q_value_new = torch.min(self.critic_1(states, actions_new), self.critic_2(states, actions_new)) #计算t时刻的q值\n",
    "        loss_actor = (alpha * log_probs_new - q_value_new).mean() #计算策略网络的损失函数\n",
    "        self.opt_actor.zero_grad()\n",
    "        loss_actor.backward()\n",
    "        self.opt_actor.step()\n",
    "        \n",
    "        loss_alpha = -(self.log_alpha * (log_probs_new + self.target_entropy).detach()).mean()\n",
    "        self.opt_alpha.zero_grad()\n",
    "        loss_alpha.backward()\n",
    "        self.opt_alpha.step()\n",
    "        self.log_alpha.data = self.log_alpha.data.clamp(-20, 2) # 限制温度参数的范围\n",
    "        ## 软更新目标值网络参数\n",
    "        for target_param, param in zip(self.critic_1_target.parameters(), self.critic_1.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.soft_update_tau) + param.data * self.soft_update_tau\n",
    "            )\n",
    "        for target_param, param in zip(self.critic_2_target.parameters(), self.critic_2.parameters()):\n",
    "            target_param.data.copy_(\n",
    "                target_param.data * (1.0 - self.soft_update_tau) + param.data * self.soft_update_tau\n",
    "            )\n",
    "        self.update_cnt += 1\n",
    "        return {'loss_critic_1': loss_critic_1.item(),\n",
    "                'loss_critic_2': loss_critic_2.item(),\n",
    "                'loss_actor': loss_actor.item(),\n",
    "                'loss_alpha': loss_alpha.item()}\n",
    "    \n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "14e02ee1",
   "metadata": {},
   "source": [
    "### 定义可视化函数"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "81469728",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "import os\n",
    "\n",
    "def smooth(data: list, weight: float = 0.9):\n",
    "    '''用于平滑曲线，类似于Tensorboard中的smooth曲线\n",
    "    '''\n",
    "    last = data[0] \n",
    "    smoothed = []\n",
    "    for point in data:\n",
    "        smoothed_val = last * weight + (1 - weight) * point  # 计算平滑值\n",
    "        smoothed.append(smoothed_val)                    \n",
    "        last = smoothed_val                                \n",
    "    return smoothed\n",
    "\n",
    "def plot_curve(cfg: Config, frames: list, rewards : list, label:str = \"rewards\", title:str = None):\n",
    "    ''' 画图\n",
    "    '''\n",
    "    if title is None:\n",
    "        title = f\"{cfg.mode}ing curve on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\"\n",
    "    sns.set_theme(style=\"darkgrid\")\n",
    "    plt.figure()  # 创建一个图形实例，方便同时多画几个图\n",
    "    plt.title(title)\n",
    "    plt.xlabel('frames')\n",
    "    plt.plot(frames, rewards, label=f\"{label}\")\n",
    "    plt.plot(frames, smooth(rewards), label=f\"{label}_smoothed\")\n",
    "    plt.legend()\n",
    "    plt.show()\n",
    "\n",
    "def print_cfgs(cfg: Config):\n",
    "    ''' 打印参数\n",
    "    '''\n",
    "    cfg_dict = vars(cfg)\n",
    "    print(\"Hyperparameters:\")\n",
    "    print(''.join(['=']*80))\n",
    "    tplt = \"{:^20}\\t{:^20}\\t{:^20}\"\n",
    "    print(tplt.format(\"Name\", \"Value\", \"Type\"))\n",
    "    allow_types = ['int', 'float', 'str', 'bool', 'list', 'dict']\n",
    "    for k,v in cfg_dict.items():\n",
    "        if v.__class__.__name__ == 'list':\n",
    "            v = str(v)\n",
    "        if v.__class__.__name__ not in allow_types:\n",
    "            continue\n",
    "        print(tplt.format(k,v,str(type(v))))   \n",
    "    print(''.join(['=']*80))\n",
    "\n",
    "def all_seed(seed: int = 0):\n",
    "    ''' 设置随机种子\n",
    "    '''\n",
    "    if seed == 0:\n",
    "        return\n",
    "    np.random.seed(seed)\n",
    "    random.seed(seed)\n",
    "    torch.manual_seed(seed) # config for CPU\n",
    "    torch.cuda.manual_seed(seed) # config for GPU\n",
    "    os.environ['PYTHONHASHSEED'] = str(seed) # config for python scripts\n",
    "    # config for cudnn\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    torch.backends.cudnn.enabled = False  \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7b4c87a",
   "metadata": {},
   "source": [
    "### 定义环境"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "92504308",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gymnasium as gym\n",
    "\n",
    "class NormalizedActions(gym.ActionWrapper):\n",
    "    def action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        \n",
    "        action = low + (action + 1.0) * 0.5 * (high - low)\n",
    "        action = np.clip(action, low, high)\n",
    "        \n",
    "        return action\n",
    "\n",
    "    def reverse_action(self, action):\n",
    "        low  = self.action_space.low\n",
    "        high = self.action_space.high\n",
    "        action = 2 * (action - low) / (high - low) - 1\n",
    "        action = np.clip(action, low, high)\n",
    "        return action\n",
    "    \n",
    "class EnvMgr:\n",
    "    def __init__(self, cfg: Config):\n",
    "        self.env = gym.make(cfg.env_id) # 创建环境\n",
    "        self.env = NormalizedActions(self.env) # 归一化动作空间\n",
    "        self.eval_env = gym.make(cfg.env_id)\n",
    "        self.eval_env = NormalizedActions(self.eval_env)\n",
    "        print(f\"env id: {cfg.env_id}, state_dim: {self.state_dim}, action_dim: {self.action_dim}\")\n",
    "    @property\n",
    "    def action_dim(self):\n",
    "        return self.env.action_space.shape[0] # 动作空间的维度\n",
    "    @property\n",
    "    def state_dim(self):\n",
    "        return self.env.observation_space.shape[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e2581771",
   "metadata": {},
   "source": [
    "## 2.模型训练与测试"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a3e3413",
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "def eval_policy(cfg: Config, policy: Policy, env):\n",
    "    ''' 测试\n",
    "    '''\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    steps = []  # 记录所有回合的步数\n",
    "    for _ in range(cfg.online_eval_episode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            action = policy.predict_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            ep_reward += reward  # 累加奖励\n",
    "            ep_step += 1\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        steps.append(ep_step)\n",
    "    \n",
    "    return {'reward': np.mean(rewards), 'step': np.mean(steps)}\n",
    "\n",
    "def train(cfg: Config, policy: Policy, env_mgr: EnvMgr):\n",
    "    ''' 训练\n",
    "    '''\n",
    "    env = env_mgr.env\n",
    "    eval_env = env_mgr.eval_env\n",
    "    rewards = []  # 记录所有回合的奖励\n",
    "    eval_rewards = []  # 记录所有回合的奖励\n",
    "    best_policy_params = None  # 最佳策略\n",
    "    best_ep_reward = float('-inf') # 最佳回合的奖励\n",
    "    tot_step = 0\n",
    "    policy_summary_dict = {} # 记录策略更新的参数，如损失等\n",
    "    for i_ep in range(cfg.max_epsiode):\n",
    "        ep_reward = 0  # 记录一回合内的奖励\n",
    "        ep_step = 0\n",
    "        state, _ = env.reset(seed = cfg.seed)  # 重置环境，返回初始状态\n",
    "        for _ in range(cfg.max_step):\n",
    "            ep_step += 1\n",
    "            tot_step += 1\n",
    "            action = policy.sample_action(state)  # 选择动作\n",
    "            next_state, reward, terminated, truncated , _ = env.step(action)  # 更新环境，返回transition\n",
    "            policy.memory.push((state, action, reward, next_state, terminated or truncated))  # 保存transition\n",
    "            state = next_state  # 更新下一个状态\n",
    "            # 更新智能体，这里也可以改成每采样50步再更新50次\n",
    "            policy_summary = policy.update()  \n",
    "            if policy_summary is not None:\n",
    "                for k, v in policy_summary.items():\n",
    "                    if k not in policy_summary_dict:\n",
    "                        policy_summary_dict[k] = []\n",
    "                    policy_summary_dict[k].append(v)\n",
    "                if policy.update_cnt > 0 and policy.update_cnt % cfg.online_eval_freq == 0:\n",
    "                    eval_res = eval_policy(cfg, policy, eval_env)\n",
    "                    eval_rewards.append(eval_res['reward'])\n",
    "                    if eval_res['reward'] >= best_ep_reward:\n",
    "                        print(f\"找到新的最优策略，回合：{i_ep+1}，模型步数：{policy.update_cnt}，测试奖励：{eval_res['reward']:.2f}, 测试回合长度：{eval_res['step']}\")\n",
    "                        best_ep_reward = eval_res['reward']\n",
    "                        best_policy_params = policy.get_policy_params()\n",
    "            # policy.update() \n",
    "            ep_reward += reward  # 累加奖励\n",
    "            if terminated or truncated:\n",
    "                break\n",
    "        rewards.append(ep_reward)\n",
    "        if (i_ep + 1) % 10 == 0:\n",
    "            print(f\"回合：{i_ep+1}/{cfg.max_epsiode}，奖励：{ep_reward:.2f}，回合长度：{ep_step}\")\n",
    "    env.close()\n",
    "    return {'rewards':rewards, 'eval_rewards':eval_rewards, 'policy_summary_dict':policy_summary_dict,'best_policy_params':best_policy_params}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "4b4294aa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "env id: Pendulum-v1, state_dim: 3, action_dim: 1\n",
      "Hyperparameters:\n",
      "================================================================================\n",
      "        Name        \t       Value        \t        Type        \n",
      "     algo_name      \t        SAC         \t   <class 'str'>    \n",
      "       env_id       \t    Pendulum-v1     \t   <class 'str'>    \n",
      "        mode        \t       train        \t   <class 'str'>    \n",
      "        seed        \t         0          \t   <class 'int'>    \n",
      "    max_epsiode     \t        100         \t   <class 'int'>    \n",
      "      max_step      \t        200         \t   <class 'int'>    \n",
      "online_eval_episode \t         10         \t   <class 'int'>    \n",
      "  online_eval_freq  \t        2000        \t   <class 'int'>    \n",
      "       gamma        \t        0.99        \t  <class 'float'>   \n",
      "    lambda_mean     \t       0.001        \t  <class 'float'>   \n",
      "     lambda_std     \t       0.001        \t  <class 'float'>   \n",
      "      lambda_z      \t        0.0         \t  <class 'float'>   \n",
      "  soft_update_tau   \t        0.01        \t  <class 'float'>   \n",
      "     lr_critic      \t       0.0003       \t  <class 'float'>   \n",
      "      lr_actor      \t       0.0003       \t  <class 'float'>   \n",
      "      lr_alpha      \t       0.0003       \t  <class 'float'>   \n",
      "    buffer_size     \t       100000       \t   <class 'int'>    \n",
      "     hidden_dim     \t        256         \t   <class 'int'>    \n",
      "     batch_size     \t        256         \t   <class 'int'>    \n",
      "       device       \t        mps         \t   <class 'str'>    \n",
      "================================================================================\n",
      "回合：10/100，奖励：-907.96，回合长度：200\n",
      "找到新的最优策略，回合：12，模型步数：2000，测试奖励：-1072.01, 测试回合长度：200.0\n",
      "回合：20/100，奖励：-254.64，回合长度：200\n",
      "找到新的最优策略，回合：22，模型步数：4000，测试奖励：-419.17, 测试回合长度：200.0\n",
      "回合：30/100，奖励：-128.54，回合长度：200\n",
      "找到新的最优策略，回合：32，模型步数：6000，测试奖励：-138.96, 测试回合长度：200.0\n",
      "回合：40/100，奖励：-126.13，回合长度：200\n",
      "回合：50/100，奖励：-129.44，回合长度：200\n",
      "回合：60/100，奖励：-250.20，回合长度：200\n",
      "回合：70/100，奖励：-126.65，回合长度：200\n",
      "回合：80/100，奖励：-130.48，回合长度：200\n",
      "回合：90/100，奖励：-127.94，回合长度：200\n",
      "找到新的最优策略，回合：92，模型步数：18000，测试奖励：-128.51, 测试回合长度：200.0\n",
      "回合：100/100，奖励：-253.78，回合长度：200\n"
     ]
    }
   ],
   "source": [
    "\n",
    "# 获取参数\n",
    "cfg = Config() \n",
    "env_mgr = EnvMgr(cfg) # 创建环境\n",
    "policy = Policy(cfg, env_mgr.state_dim, env_mgr.action_dim) # 创建策略\n",
    "all_seed(cfg.seed)\n",
    "print_cfgs(cfg)\n",
    "res = train(cfg, policy, env_mgr) # 训练\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "bd90699a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_curve(cfg, range(len(res['rewards'])), res['rewards'], label = \"rewards\", title = f\"{cfg.mode}ing rewards on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "for k, v in res['policy_summary_dict'].items():\n",
    "    plot_curve(cfg, range(len(v)), v, label = k, title = f\"{cfg.mode}ing {k} on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")\n",
    "plot_curve(cfg, range(len(res['eval_rewards'])), res['eval_rewards'], label = \"eval_rewards\", title = f\"online eval reward on {cfg.device} of {cfg.algo_name} for {cfg.env_id}\")"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "joyrl-book",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.14"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
